home *** CD-ROM | disk | FTP | other *** search
/ IRIX Patches 1995 June / SGI IRIX Patches 1995 Jun.iso / 5.3_patches / patchSG0000499 / patchSG0000499.idb / usr / include / abi / X11 / extensions / XKBstr.h.z / XKBstr.h
Encoding:
C/C++ Source or Header  |  1995-06-12  |  13.6 KB  |  472 lines
  1. /* $XConsortium: XKBstr.h,v 1.10 94/04/08 02:57:04 erik Exp $ */
  2. /************************************************************
  3. Copyright (c) 1993 by Silicon Graphics Computer Systems, Inc.
  4.  
  5. Permission to use, copy, modify, and distribute this
  6. software and its documentation for any purpose and without
  7. fee is hereby granted, provided that the above copyright
  8. notice appear in all copies and that both that copyright
  9. notice and this permission notice appear in supporting
  10. documentation, and that the name of Silicon Graphics not be 
  11. used in advertising or publicity pertaining to distribution 
  12. of the software without specific prior written permission.
  13. Silicon Graphics makes no representation about the suitability 
  14. of this software for any purpose. It is provided "as is"
  15. without any express or implied warranty.
  16.  
  17. SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS 
  18. SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY 
  19. AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON
  20. GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL 
  21. DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, 
  22. DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE 
  23. OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION  WITH
  24. THE USE OR PERFORMANCE OF THIS SOFTWARE.
  25.  
  26. ********************************************************/
  27.  
  28. #ifndef _XKBSTR_H_
  29. #define    _XKBSTR_H_
  30.  
  31. #include <X11/extensions/XKB.h>
  32.  
  33. #define    XkbCharToInt(v)        ((v)&0x80?(int)((v)|(~0xff)):(int)((v)&0x7f))
  34. #define    XkbIntTo2Chars(i,h,l)    (((h)=((i>>8)&0xff)),((l)=((i)&0xff)))
  35.  
  36. #if defined(WORD64) && defined(UNSIGNEDBITFIELDS)
  37. #define    Xkb2CharsToInt(h,l)    ((h)&0x80?(int)(((h)<<8)|(l)|(~0xffff)):\
  38.                       (int)(((h)<<8)|(l)&0x7fff))
  39. #else
  40. #define    Xkb2CharsToInt(h,l)    ((short)(((h)<<8)|(l)))
  41. #endif
  42.  
  43.     /*
  44.      * Common data structures and access macros
  45.      */
  46.  
  47. typedef struct _XkbStateRec {
  48.     unsigned char    group;
  49.     unsigned char    base_group;
  50.     unsigned char    latched_group;
  51.     unsigned char   locked_group;
  52.     unsigned char    mods;
  53.     unsigned char    base_mods;
  54.     unsigned char    latched_mods;
  55.     unsigned char    locked_mods;
  56.     unsigned char    compat_state;
  57. } XkbStateRec,*XkbStatePtr;
  58. #define    XkbModLocks(s)     ((s)->locked_mods)
  59. #define    XkbStateMods(s)     ((s)->base_mods|(s)->latched_mods|XkbModLocks(s))
  60. #define    XkbGroupLock(s)     ((s)->locked_group)
  61. #define    XkbStateGroup(s) ((s)->base_group+(s)->latched_group+XkbGroupLock(s))
  62.  
  63. typedef struct _XkbKTMapEntry {
  64.     Bool        active;
  65.     unsigned char    mask;    /* effective mods */
  66.     unsigned char    level;
  67.     unsigned char    real_mods;
  68.     unsigned short    vmods;
  69. } XkbKTMapEntryRec,*XkbKTMapEntryPtr;
  70.  
  71. typedef struct _XkbKTPreserve {
  72.     unsigned char    mask;
  73.     unsigned char    real_mods;
  74.     unsigned short    vmods;
  75. } XkbKTPreserveRec, *XkbKTPreservePtr;
  76.  
  77. typedef struct _XkbKeyType {
  78.     unsigned char      mask;
  79.     unsigned char      real_mods;
  80.     unsigned short      vmods;
  81.     unsigned char      group_width;
  82.     unsigned char      free;
  83.     unsigned char      map_count;
  84.     XkbKTMapEntryPtr  map;
  85.     XkbKTPreservePtr  preserve;
  86.     Atom          name;
  87.     Atom         *lvl_names;
  88. } XkbKeyTypeRec, *XkbKeyTypePtr;
  89. #define    XkbNoFreeKTLevelNames    (1<<4)
  90. #define    XkbNoFreeKTPreserve    (1<<5)
  91. #define    XkbNoFreeKTMap        (1<<6)
  92. #define    XkbNoFreeKTStruct    (1<<7)
  93.  
  94. #define    XkbNumGroups(g)        ((g)&0x1f)
  95. #define    XkbGroupsWrap(g)    (((g)&0x80)!=0)
  96. #define    XkbSetGroupInfo(g,w)    (((w)?0x80:0x00)|((g)&0x1f))
  97. #define    XkbSetNumGroups(g,n)    (((g)&0x80)|((n)&0x1f))
  98. #define    XkbSetGroupsWrap(g,w)    (((w)?0x80:0x00)|((g)&0x1f))
  99.  
  100.     /*
  101.      * Structures and access macros used primarily by the server
  102.      */
  103.  
  104. typedef struct _XkbBehavior {
  105.     unsigned char    type;
  106.     unsigned char    data;
  107. } XkbBehavior;
  108.  
  109. #define    XkbAnyActionDataSize 7
  110. typedef    struct _XkbAnyAction {
  111.     unsigned char    type;
  112.     unsigned char    data[XkbAnyActionDataSize];
  113. } XkbAnyAction;
  114.  
  115. typedef struct _XkbModAction {
  116.     unsigned char    type;
  117.     unsigned char    flags;
  118.     unsigned char    mask;
  119.     unsigned char    real_mods;
  120.     unsigned char    vmods1;
  121.     unsigned char    vmods2;
  122. } XkbModAction;
  123. #define    XkbModActionVMods(a)      \
  124.     ((short)(((a)->vmods1<<8)|((a)->vmods2)))
  125. #define    XkbSetModActionVMods(a,v) \
  126.     (((a)->vmods1=(((v)>>8)&0xff)),(a)->vmods2=((v)&0xff))
  127.  
  128. typedef struct _XkbGroupAction {
  129.     unsigned char    type;
  130.     unsigned char    flags;
  131.     char        group_XXX;
  132. } XkbGroupAction;
  133. #define    XkbSAGroup(a)        (XkbCharToInt((a)->group_XXX))
  134. #define    XkbSASetGroup(a,g)    ((a)->group_XXX=(g))
  135.  
  136. typedef struct _XkbISOAction {
  137.     unsigned char    type;
  138.     unsigned char    flags;
  139.     unsigned char    mask;
  140.     unsigned char    real_mods;
  141.     char        group_XXX;
  142.     unsigned char    affect;
  143.     unsigned char    vmods1;
  144.     unsigned char    vmods2;
  145. } XkbISOAction;
  146.  
  147. typedef struct _XkbPtrAction {
  148.     unsigned char    type;
  149.     unsigned char    flags;
  150.     unsigned char    high_XXX;
  151.     unsigned char    low_XXX;
  152.     unsigned char    high_YYY;
  153.     unsigned char    low_YYY;
  154. } XkbPtrAction;
  155. #define    XkbPtrActionX(a)      (Xkb2CharsToInt((a)->high_XXX,(a)->low_XXX))
  156. #define    XkbPtrActionY(a)      (Xkb2CharsToInt((a)->high_YYY,(a)->low_YYY))
  157. #define    XkbSetPtrActionX(a,x) (XkbIntTo2Chars(x,(a)->high_XXX,(a)->low_XXX))
  158. #define    XkbSetPtrActionY(a,y) (XkbIntTo2Chars(y,(a)->high_YYY,(a)->low_YYY))
  159.  
  160. typedef struct _XkbPtrBtnAction {
  161.     unsigned char    type;
  162.     unsigned char    flags;
  163.     unsigned char    count;
  164.     unsigned char    button;
  165. } XkbPtrBtnAction;
  166.  
  167. typedef struct _XkbPtrDfltAction {
  168.     unsigned char    type;
  169.     unsigned char    flags;
  170.     unsigned char    affect;
  171.     char        valueXXX;
  172. } XkbPtrDfltAction;
  173. #define    XkbSAPtrDfltValue(a)        (XkbCharToInt((a)->valueXXX))
  174. #define    XkbSASetPtrDfltValue(a,c)    ((a)->valueXXX= ((c)&0xff))
  175.  
  176. typedef struct _XkbSwitchScreenAction {
  177.     unsigned char    type;
  178.     unsigned char    flags;
  179.     char        screenXXX;
  180. } XkbSwitchScreenAction;
  181. #define    XkbSAScreen(a)            (XkbCharToInt((a)->screenXXX))
  182. #define    XkbSASetScreen(a,s)        ((a)->screenXXX= ((s)&0xff))
  183.  
  184. typedef struct _XkbCtrlsAction {
  185.     unsigned char    type;
  186.     unsigned char    flags;
  187.     unsigned char    ctrls3;
  188.     unsigned char    ctrls2;
  189.     unsigned char    ctrls1;
  190.     unsigned char    ctrls0;
  191. } XkbCtrlsAction;
  192. #define    XkbActionSetCtrls(a,c)    (((a)->ctrls3=(((c)>>24)&0xff)),\
  193.                     ((a)->ctrls2=(((c)>>16)&0xff)),\
  194.                     ((a)->ctrls1=(((c)>>8)&0xff)),\
  195.                     ((a)->ctrls0=((c)&0xff)))
  196. #define    XkbActionCtrls(a) ((((unsigned)(a)->ctrls3)<<24)|\
  197.                (((unsigned)(a)->ctrls2)<<16)|\
  198.                (((unsigned)(a)->ctrls1)<<8)|((a)->ctrls0))
  199.  
  200. typedef struct _XkbMessageAction {
  201.     unsigned char    type;
  202.     unsigned char    flags;
  203.     unsigned char    message[6];
  204. } XkbMessageAction;
  205.  
  206. typedef    union _XkbAction {
  207.     XkbAnyAction        any;
  208.     XkbModAction        mods;
  209.     XkbGroupAction        group;
  210.     XkbISOAction        iso;
  211.     XkbPtrAction        ptr;
  212.     XkbPtrBtnAction        btn;
  213.     XkbPtrDfltAction    dflt;
  214.     XkbSwitchScreenAction    screen;
  215.     XkbCtrlsAction        ctrls;
  216.     XkbMessageAction    msg;
  217.     unsigned char         type;
  218. } XkbAction;
  219.  
  220. typedef    struct _XkbControls {
  221.     unsigned char    mouse_keys_dflt_btn;
  222.     unsigned char    num_groups;
  223.     unsigned char    internal_mask;
  224.     unsigned char    ignore_lock_mask;
  225.     unsigned char    internal_real_mods;
  226.     unsigned char    ignore_lock_real_mods;
  227.     unsigned short    internal_vmods;
  228.     unsigned short    ignore_lock_vmods;
  229.     unsigned char    accessx_options;
  230.     unsigned int    enabled_ctrls;
  231.     unsigned short    repeat_delay;
  232.     unsigned short    repeat_interval;
  233.     unsigned short    slow_keys_delay;
  234.     unsigned short    debounce_delay;
  235.     unsigned short    mouse_keys_delay;
  236.     unsigned short    mouse_keys_interval;
  237.     unsigned short    mouse_keys_time_to_max;
  238.     unsigned short    mouse_keys_max_speed;
  239.     unsigned short    mouse_keys_curve;
  240.     unsigned short    accessx_timeout;
  241.     unsigned int    accessx_timeout_mask;
  242. } XkbControlsRec, *XkbControlsPtr;
  243.  
  244. #define    XkbAX_AnyFeedback(c)    ((c)->enabled_ctrls&XkbAccessXFeedbackMask)
  245. #define    XkbAX_NeedOption(c,w)    ((c)->accessx_options&(w))
  246. #define    XkbAX_NeedFeedback(c,w)    (XkbAX_AnyFeedback(c)&&XkbAX_NeedOption(c,w))
  247.  
  248. typedef struct _XkbServerMapRec {
  249.     unsigned short         num_acts;
  250.     unsigned short         size_acts;
  251.     XkbAction        *acts;
  252.  
  253.     XkbBehavior        *behaviors;
  254.     unsigned short        *key_acts;
  255.     unsigned char        *explicit;
  256.     unsigned char         vmods[XkbNumVirtualMods];
  257. } XkbServerMapRec, *XkbServerMapPtr;
  258.  
  259. #define    XkbSMKeyActionsPtr(m,k) (&(m)->acts[(m)->key_acts[k]])
  260.  
  261.     /*
  262.      * Structures and access macros used primarily by clients
  263.      */
  264.  
  265. typedef    struct _XkbSymMapRec {
  266.     unsigned char     kt_index;
  267.     unsigned char     group_info;
  268.     unsigned short     offset;
  269. } XkbSymMapRec, *XkbSymMapPtr;
  270.  
  271. typedef struct _XkbClientMapRec {
  272.     unsigned char         size_types;
  273.     unsigned char         num_types;
  274.     XkbKeyTypeRec        *types;
  275.  
  276.     unsigned short         size_syms;
  277.     unsigned short         num_syms;
  278.     KeySym            *syms;
  279.     XkbSymMapRec        *key_sym_map;
  280. } XkbClientMapRec, *XkbClientMapPtr;
  281.  
  282. #define    XkbCMKeyGroupsWrap(m,k) (XkbGroupsWrap((m)->key_sym_map[k].group_info))
  283. #define    XkbCMKeyNumGroups(m,k)    (XkbNumGroups((m)->key_sym_map[k].group_info))
  284. #define    XkbCMKeyGroupWidth(m,k)    (XkbCMKeyType(m,k)->group_width)
  285. #define    XkbCMKeyTypeIndex(m,k)    ((m)->key_sym_map[k].kt_index)
  286. #define    XkbCMKeyType(m,k)    (&(m)->types[XkbCMKeyTypeIndex(m,k)])
  287. #define    XkbCMKeyNumSyms(m,k)    (XkbCMKeyGroupWidth(m,k)*XkbCMKeyNumGroups(m,k))
  288. #define    XkbCMKeySymsOffset(m,k)    ((m)->key_sym_map[k].offset)
  289. #define    XkbCMKeySymsPtr(m,k)    (&(m)->syms[XkbCMKeySymsOffset(m,k)])
  290.  
  291.     /*
  292.      * Compatibility structures and access macros
  293.      */
  294.  
  295. typedef struct _XkbModCompatRec {
  296.     unsigned char    mods;
  297.     unsigned char    groups;
  298. } XkbModCompatRec,*XkbModCompatPtr;
  299.  
  300. typedef struct _XkbSymInterpretRec {
  301.     KeySym        sym;
  302.     unsigned char    flags;
  303.     unsigned char    match;
  304.     unsigned char    mods;
  305.     unsigned char    virtual_mod;
  306.     XkbAnyAction    act;
  307. } XkbSymInterpretRec,*XkbSymInterpretPtr;
  308.  
  309. typedef struct _XkbCompatRec {
  310.     XkbSymInterpretRec    *sym_interpret;
  311.     XkbModCompatRec         real_mod_compat[XkbNumModifiers];
  312.     XkbModCompatRec         vmod_compat[XkbNumVirtualMods];
  313.     XkbModCompatPtr         mod_compat[XkbNumModifiers];
  314.     unsigned short         num_si;
  315.     unsigned short         size_si;
  316. } XkbCompatRec, *XkbCompatPtr;
  317.  
  318. typedef struct _XkbIndicatorMapRec {
  319.     unsigned char    flags;
  320.     unsigned char    which_groups;
  321.     unsigned char    groups;
  322.     unsigned char    which_mods;
  323.     unsigned char    mask;
  324.     unsigned char    real_mods;
  325.     unsigned short    vmods;
  326.     unsigned int    ctrls;
  327. } XkbIndicatorMapRec, *XkbIndicatorMapPtr;
  328.  
  329. typedef struct _XkbIndicatorRec {
  330.     unsigned char          num_phys_indicators;
  331.     XkbIndicatorMapRec    maps[XkbNumIndicators];
  332. } XkbIndicatorRec,*XkbIndicatorPtr;
  333.  
  334. typedef    struct _XkbKeyNameRec {
  335.     char    name[4];
  336. } XkbKeyNameRec,*XkbKeyNamePtr;
  337.  
  338.     /*
  339.      * Names for everything 
  340.      */
  341. typedef struct _XkbNamesRec {
  342.     Atom          keycodes;
  343.     Atom          geometry;
  344.     Atom          symbols;
  345.     Atom          semantics;
  346.     Atom          mods[XkbNumModifiers];
  347.     Atom          vmods[XkbNumVirtualMods];
  348.     Atom          indicators[XkbNumIndicators];
  349.     XkbKeyNamePtr      keys;
  350.     Atom         *radio_groups;
  351.     Atom         *char_sets;
  352.     Atom          phys_symbols;
  353.     Atom          phys_geometry;
  354.  
  355.     unsigned char      num_keys;
  356.     unsigned short      num_rg;
  357.     unsigned short      num_char_sets;
  358. } XkbNamesRec,*XkbNamesPtr;
  359.  
  360.     /*
  361.      * Alternate Symbol Sets
  362.      */
  363. typedef struct _XkbAlternateSymsRec {
  364.     Atom         name;
  365.     unsigned char     index;
  366.     unsigned char     num_char_sets;
  367.     Atom        *char_sets;
  368.     unsigned char     first_key;
  369.     unsigned char     num_keys;
  370.     unsigned short     num_syms;
  371.     unsigned short     size_syms;
  372.     KeySym        *syms;
  373.     XkbSymMapRec    *maps;
  374.     struct _XkbAlternateSymsRec    *next;
  375. } XkbAlternateSymsRec, *XkbAlternateSymsPtr;
  376.  
  377. typedef    struct _XkbGeometry    *XkbGeometryPtr;
  378.     /*
  379.      * Tie it all together into one big keyboard description
  380.      */
  381. typedef    struct _XkbDesc {
  382.     unsigned short         flags;
  383.     unsigned short        device_spec;
  384.     KeyCode            min_key_code;
  385.     KeyCode            max_key_code;
  386.  
  387.     XkbControlsPtr        ctrls;
  388.     XkbServerMapPtr        server;
  389.     XkbClientMapPtr        map;
  390.     XkbIndicatorPtr        indicators;
  391.     XkbNamesPtr        names;
  392.     XkbCompatPtr        compat;
  393.     XkbAlternateSymsPtr    alt_syms;
  394.     XkbGeometryPtr        geom;
  395. } XkbDescRec, *XkbDescPtr;
  396. #define    XkbKeyKeyTypeIndex(d,k)    (XkbCMKeyTypeIndex((d)->map,k))
  397. #define    XkbKeyKeyType(d,k)    (XkbCMKeyType((d)->map,k))
  398. #define    XkbKeyGroupWidth(d,k)    (XkbKeyKeyType(d,k)->group_width)
  399. #define    XkbKeyGroupsWrap(d,k)    (XkbCMKeyGroupsWrap((d)->map,(k)))
  400. #define    XkbKeyNumGroups(d,k)    (XkbCMKeyNumGroups((d)->map,(k)))
  401. #define    XkbKeyNumSyms(d,k)    (XkbCMKeyNumSyms((d)->map,(k)))
  402. #define    XkbKeySymsPtr(d,k)    (XkbCMKeySymsPtr((d)->map,(k)))
  403. #define    XkbKeySym(d,k,n)    (XkbKeySymsPtr(d,k)[n])
  404.  
  405. #define    XkbKeyHasActions(d,k)    ((d)->server->key_acts[k]!=0)
  406. #define    XkbKeyNumActions(d,k)    (XkbKeyHasActions(d,k)?XkbKeyNumSyms(d,k):1)
  407. #define    XkbKeyActionsPtr(d,k)    (XkbSMKeyActionsPtr((d)->server,k))
  408. #define    XkbNumKeys(d)        ((d)->max_key_code-(d)->min_key_code+1)
  409.  
  410. typedef struct _XkbMapChanges {
  411.     unsigned short         changed;
  412.     unsigned char         first_type;
  413.     unsigned char         num_types;
  414.     unsigned char         first_key_sym;
  415.     unsigned char         num_key_syms;
  416.     unsigned char         first_key_act;
  417.     unsigned char         num_key_acts;
  418.     unsigned char         first_key_behavior;
  419.     unsigned char         num_key_behaviors;
  420.     unsigned short         vmods;
  421.     unsigned char         first_key_explicit;
  422.     unsigned char         num_key_explicit;
  423. } XkbMapChangesRec,*XkbMapChangesPtr;
  424.  
  425. typedef struct _XkbControlsChanges {
  426.     unsigned          changed_ctrls;
  427.     unsigned         enabled_ctrls_changes;
  428. } XkbControlsChangesRec,*XkbControlsChangesPtr;
  429.  
  430. typedef struct _XkbIndicatorChanges {
  431.     unsigned         state_changes;
  432.     unsigned         map_changes;
  433. } XkbIndicatorChangesRec,*XkbIndicatorChangesPtr;
  434.  
  435. typedef struct _XkbNameChanges {
  436.     unsigned short        changed;
  437.     unsigned char        first_type;
  438.     unsigned char        num_types;
  439.     unsigned char        first_lvl;
  440.     unsigned char        num_lvls;
  441.     unsigned char        first_rg;
  442.     unsigned char        num_rg;
  443.     unsigned        changed_indicators;
  444.     unsigned char        changed_mods;
  445.     unsigned short        changed_vmods;
  446. } XkbNameChangesRec,*XkbNameChangesPtr;
  447.  
  448. typedef struct _XkbCompatChanges {
  449.     unsigned char        changed_mods;
  450.     unsigned short        changed_vmods;
  451.     unsigned short        first_si;
  452.     unsigned short        num_si;
  453. } XkbCompatChangesRec,*XkbCompatChangesPtr;
  454.  
  455. typedef struct _XkbAlternateSymChanges {
  456.     unsigned char        id;
  457.     unsigned char        first_key;
  458.     unsigned char        num_keys;
  459. } XkbAlternateSymChanges,*XkbAlternateSymsChangesPtr;
  460.  
  461. typedef struct _XkbChanges {
  462.     unsigned short         device_spec;
  463.     unsigned short         state_changes;
  464.     XkbMapChangesRec     map;
  465.     XkbControlsChangesRec     ctrls;
  466.     XkbIndicatorChangesRec     indicators;
  467.     XkbNameChangesRec     names;
  468.     XkbCompatChangesRec     compat;
  469. } XkbChangesRec, *XkbChangesPtr;
  470.  
  471. #endif /* _XKBSTR_H_ */
  472.